import { plot } from '@/components/ol/plotting/plotting.js'
import * as olProj from 'ol/proj' // 坐标变换使用

export default {
  data () {
    return {
      solPlotID: null, // 方案数据使用的军标ID（名称，如：dir_lu）
      num: 0
    }
  },
  watch: {
    // watch
  },
  mounted () {
    // mounted
  },
  methods: {
    /**
     * @description 根据sol的数据动态生成军标
     * @param oSolData {Object} sol的数据-用来生成军标
     * @return
     */
    // async solData2Plot_old (oSolData) { // [{sPlotID：绘制军标名称，aPnts：控制点[经度，纬度]，aUnit：军标宽高，sTxt是否有文字},{}]
    // // const aPlotIDLs = ['dire_bm_fajjd', 'dire_bm_fassd']
    // // const aPlotCoord = [[116.283662, 39.88856], [116.388584, 39.880421]]
    // // console.log(aPlotIDLs.length)
    // // // this.data2plot(aPlotIDLs[0], [[0, 0]], [1000, 1000])
    // // for (let i = 0; i < aPlotIDLs.length; i++) {
    // //   this.$parent.iActType = aPlotIDLs[i]
    // //   console.log(aPlotIDLs[i], [aPlotCoord[i]], [1000, 1000])
    // //   this.data2plot(aPlotIDLs[i], [aPlotCoord[i]], [1000, 1000])
    // //   await this.sleep(500)
    // // }
    // // this.data2plot('mult_getSimpleArrowEW', aPlotCoord, [1000, 1000], '5000人')
    //   if (oSolData && oSolData.length > 0) {
    //     for (let i = 0; i < oSolData.length; i++) {
    //       // 等宽箭头处理
    //       if (oSolData[i].sPlotID === 'mult_getSimpleArrowEW' || oSolData[i].sPlotID === 'mult_getSSArrowPnts' || oSolData[i].sPlotID === 'mult_dashArrowPnts') {
    //         this.iType = oSolData[i].sPlotID // 'mult_getSimpleArrowEW'
    //         // console.log(oSolData[i].sPlotID, oSolData[i].aPnts, oSolData[i].aUnit, oSolData[i].sTxt)
    //         this.data2plot(oSolData[i].sPlotID, oSolData[i].aPnts, oSolData[i].aUnit, oSolData[i].sTxt, oSolData[i].oPop)
    //         await this.sleep(500)
    //       } else if (oSolData[i].sPlotID === 'mult_pathArrowPnts' || oSolData[i].sPlotID === 'mult_dashPathArrowPnts') { // 路径箭头处理
    //         this.iType = oSolData[i].sPlotID // 'mult_pathArrowPnts'
    //         // console.log(oSolData[i].aPnts, oSolData[i].aPathPnts)
    //         const inpoints = oSolData[i].aPathPnts
    //         if (oSolData[i].aPnts[0]) {
    //           inpoints.splice(0, 0, oSolData[i].aPnts[0])
    //         }
    //         if (oSolData[i].aPnts[1]) {
    //           inpoints.push(oSolData[i].aPnts[1])
    //         }
    //         // console.log(inpoints)
    //         this.data2plot(oSolData[i].sPlotID, inpoints, oSolData[i].aUnit, oSolData[i].sTxt, oSolData[i].oPop)
    //         await this.sleep(500)
    //       } else { // 处理其他类型军标
    //         this.data2plot(oSolData[i].sPlotID, oSolData[i].aPnts, oSolData[i].aUnit, oSolData[i].sTxt, oSolData[i].oPop)
    //         await this.sleep(500)
    //       }
    //     }
    //     this.iType = null
    //   }
    // },
    async solData2Plot_old_915 (oSolData) { // [{sPlotID：绘制军标名称，aPnts：控制点[经度，纬度]，aUnit：军标宽高，sTxt是否有文字, oPop气泡提示信息},{}]
      if (oSolData && oSolData.length > 0) {
        for (let i = 0; i < oSolData.length; i++) {
          // 等宽箭头处理
          if (oSolData[i].sPlotID === 'mult_getSimpleArrowEW' || oSolData[i].sPlotID === 'mult_getSSArrowPnts' || oSolData[i].sPlotID === 'mult_dashArrowPnts') {
            this.iType = oSolData[i].sPlotID // 'mult_getSimpleArrowEW'
            // console.log(oSolData[i].sPlotID, oSolData[i].aPnts, oSolData[i].aUnit, oSolData[i].sTxt)
            this.data2plot(oSolData[i].sPlotID, oSolData[i].sPlotType, oSolData[i].aPnts, oSolData[i].aUnit, oSolData[i].sTxt, oSolData[i].oPop)
            await this.sleep(500)
          } else if (oSolData[i].sPlotID === 'mult_pathArrowPnts' || oSolData[i].sPlotID === 'mult_dashPathArrowPnts') { // 路径箭头处理
            this.iType = oSolData[i].sPlotID // 'mult_pathArrowPnts'
            // console.log(oSolData[i].aPnts, oSolData[i].aPathPnts)
            const inpoints = oSolData[i].aPathPnts
            if (oSolData[i].aPnts[0]) {
              inpoints.splice(0, 0, oSolData[i].aPnts[0])
            }
            if (oSolData[i].aPnts[1]) {
              inpoints.push(oSolData[i].aPnts[1])
            }
            // console.log(inpoints)
            this.data2plot(oSolData[i].sPlotID, oSolData[i].sPlotType, inpoints, oSolData[i].aUnit, oSolData[i].sTxt, oSolData[i].oPop)
            await this.sleep(500)
          } else { // 处理其他类型军标
            this.data2plot(oSolData[i].sPlotID, oSolData[i].sPlotType, oSolData[i].aPnts, oSolData[i].aUnit, oSolData[i].sTxt, oSolData[i].oPop)
            await this.sleep(500)
          }
        }
        this.iType = null
      }
    },

    async solData2Plot (oSolData) { // [{sPlotID：军标的唯一ID, sPlotType:绘制军标类型名称，aPnts：控制点[经度，纬度]，aUnit：军标宽高，sTxt是否有文字, oPop气泡提示信息},{}]
      if (oSolData && oSolData.length > 0) {
        for (let i = 0; i < oSolData.length; i++) {
          // 等宽箭头处理
          if (oSolData[i].sPlotType === 'mult_getSimpleArrowEW' || oSolData[i].sPlotType === 'mult_getSSArrowPnts' || oSolData[i].sPlotType === 'mult_dashArrowPnts') {
            this.iType = oSolData[i].sPlotType // 'mult_getSimpleArrowEW'
            // console.log(oSolData[i].sPlotID, oSolData[i].aPnts, oSolData[i].aUnit, oSolData[i].sTxt)
            this.data2plot(oSolData[i].sPlotID, oSolData[i].sPlotType, oSolData[i].aPnts, oSolData[i].aUnit, oSolData[i].sTxt, oSolData[i].oPop)
            await this.sleep(500)
          } else if (oSolData[i].sPlotType === 'mult_pathArrowPnts' || oSolData[i].sPlotType === 'mult_dashPathArrowPnts') { // 路径箭头处理
            this.iType = oSolData[i].sPlotType // 'mult_pathArrowPnts'
            // console.log(oSolData[i].aPnts, oSolData[i].aPathPnts)
            const inpoints = oSolData[i].aPathPnts
            if (oSolData[i].aPnts[0]) {
              inpoints.splice(0, 0, oSolData[i].aPnts[0])
            }
            if (oSolData[i].aPnts[1]) {
              inpoints.push(oSolData[i].aPnts[1])
            }
            // console.log(inpoints)
            this.data2plot(oSolData[i].sPlotID, oSolData[i].sPlotType, inpoints, oSolData[i].aUnit, oSolData[i].sTxt, oSolData[i].oPop)
            await this.sleep(500)
          } else if (oSolData[i].sPlotType === 'updatePlotPopInfo') { // 更新气泡数据
            // await this.sleep(500)
            // updataPlotPopInfo(sPlotIDk, aPnts, oPop, sPlotType = 'icon_')
            this.updatePlotPopInfo(oSolData[i].sPlotID, oSolData[i].aPnts, oSolData[i].oPop) // 新添加的更新气泡信息
          } else if (oSolData[i].sPlotType === 'updatePlotTxtInfo') {
            // console.log(oSolData[i].sPlotID, oSolData[i].aPnts, oSolData[i].sTxt, sPlotType = 'icon_') -- 默认 sPloType =''
            this.updatePlotTxtInfo(oSolData[i].sPlotID, oSolData[i].aPnts, oSolData[i].sTxt)
          } else if (oSolData[i].sPlotType === 'route') { // 处理其他类型军标
            this.data2plot(oSolData[i].sPlotID, oSolData[i].sPlotType, oSolData[i].aPnts, oSolData[i].aUnit, oSolData[i].sTxt, oSolData[i].oPop, oSolData[i].sColor)
            await this.sleep(500)
          } else { // 处理其他类型军标
            this.data2plot(oSolData[i].sPlotID, oSolData[i].sPlotType, oSolData[i].aPnts, oSolData[i].aUnit, oSolData[i].sTxt, oSolData[i].oPop)
            await this.sleep(500)
          }
        }
        this.iType = null
        // debug
        // for (let i = 0; i < this.xData.length; i++) {
        //   console.log(this.xData[i].id)
        //   console.log('==================================', i)
        // }
      }
    },

    /**
     * @description 判断是否为对象--暂时未使用
     * @param obj {object} 待验证元素
     * @return bool
     */
    // 判断obj是否为json对象
    isJson (obj) {
      // var isjson = typeof(obj) == "object" && Object.prototype.toString.call(obj).toLowerCase() == "[object object]" && !obj.length;
      const isjson = typeof (obj) === 'object' && !Array.isArray(obj)
      return isjson
    },

    /**
     * @description 更新军标气泡信息
     * @param sPlotID {String}军标ID（名称）, aPnts {Array} 添加，或是删除, [add 或 del]--更新等同add
     *        oPop {Object} 军标的气泡信息，默认为空null表示不添加，sPlotType 默认为''测试为'icon_'
     * @return 无
     */
    updatePlotPopInfo (sPlotIDk, aPnts, oPop, sPlotType = '') {
      // 首先关闭气泡
      // 查看军标是否存在-不存在推出
      // 查看气泡是否存在-不存在删除退出
      // 检查气泡中的key是否存在-不存在删除退出

      // 添加气泡数据无效时退出
      if (!this.isJson(oPop)) return
      // 找不到军标数据，退出
      const sID = sPlotType + sPlotIDk
      const oPlotData = this.getPlotFromXData(sID) // sPlotType + sPlotID
      if (!oPlotData) return
      // console.log(oPlotData, aPnts) // debug
      // 更新动作确认
      let sAct = 'add'
      // if (aPnts !== null && aPnts.length> 0) {
      if (aPnts) {
        // console.log(aPnts !== null, aPnts.length, aPnts[0].toLowerCase())
        if (aPnts.length > 0) {
          sAct = aPnts[0].toLowerCase()
        }
      }
      // console.log(sAct, sAct !== 'add', sAct !== 'del')
      if (sAct !== 'add' && sAct !== 'del' && sAct !== 'cls') {
        sAct = 'add'
      }
      // 更新
      if (sAct === 'add') {
        if (oPlotData.pop) { // 有气泡信息
          // key存在时，更新数据；不存在时添加
          for (const item in oPop) {
            // oPlotData.[item] = oPop[item]
            oPlotData.pop[item] = oPop[item]
          }
        } else { // 没有气泡信息--直接添加即可
          oPlotData.pop = oPop
        }
        // 更新xData数据
        console.log(oPlotData)
        this.updatePlot(sID, oPlotData) // sPlotType + sPlotIDk
        const plotElement = this.getPlotFromXData(sID) // 获取元素
        plotElement.TS = new Date().getTime() // 添加修改时间
        this.plotRecordUpdate(plotElement, 'U') // 更新数据
      } else if (sAct === 'del') {
        if (oPlotData.pop) { // 有气泡信息
          for (const item in oPop) {
            delete oPlotData.pop[item]
          }
          // 更新xData数据
          this.updatePlot(sID, oPlotData) // sPlotType + sPlotIDk
          const plotElement = this.getPlotFromXData(sID) // 获取元素
          plotElement.TS = new Date().getTime() // 添加修改时间
          this.plotRecordUpdate(plotElement, 'U') // 更新数据
        } // 没有气泡信息--不用处理
      } else if (sAct === 'cls') {
        if (oPlotData.pop) { // 有气泡信息
          oPlotData.pop = null
          // 更新xData数据
          this.updatePlot(sID, oPlotData) // sPlotType + sPlotIDk
          const plotElement = this.getPlotFromXData(sID) // 获取元素
          plotElement.TS = new Date().getTime() // 添加修改时间
          this.plotRecordUpdate(plotElement, 'U') // 更新数据
        }
      }
      console.log(this.currPlot)
    },

    /**
     * @description 更新军标Txt信息
     * @param sPlotID {String}军标ID（名称）, aPnts {Array} 添加，替换，删除, [add 或 del]--更新等同add
     *        sTxt {String} 军标的文字信息，sPlotType 军标样式，默认为空
     * @return 无
     */
    updatePlotTxtInfo (sPlotIDk, aPnts, sTxt, sPlotType = '') {
      const sID = sPlotType + sPlotIDk
      // 查看军标是否存在-不存在退出--带文字的军标
      const oPlotData = this.getPlotFromXData(sID) // sPlotType + sPlotIDk
      // console.log(sID, JSON.parse(JSON.stringify(oPlotData)))
      if (!oPlotData) return
      // sPlotType = oPlotData.name.substr(0, 5).toLowerCase()
      // if (sPlotType !== 'icon_' && sPlotType !== 'dire_' && sPlotType !== 'ddir_' && sPlotType !== 'mult_') {
      //   sPlotType = ''
      // }
      // const sTxtID = 'text_' + sPlotType + sPlotIDk
      // console.log(sTxtID)
      // console.dir(this.xData)
      // 确认当前操作
      let sAct = 'add'
      // if (aPnts !== null && aPnts.length> 0) {
      if (aPnts) {
        // console.log(aPnts !== null, aPnts.length, aPnts[0].toLowerCase())
        if (aPnts.length > 0) {
          sAct = String(aPnts[0]).toLowerCase()
        }
      }
      // console.log(sAct, sAct !== 'add', sAct !== 'del')
      if (sAct !== 'add' && sAct !== 'del' && sAct !== 'replace') {
        sAct = 'replace'
      }
      // 更新
      if (sAct === 'add') {
        let iCount
        if (oPlotData.attach) { // 有TXT关联信息
          const sLastTxtId = oPlotData.attach[oPlotData.attach.length - 1] // 是否要判断 数据是数组？
          const aTxtIdx = sLastTxtId.split('_') // 获取数据
          const sTxtIdx = aTxtIdx[aTxtIdx.length - 1]
          console.log(sTxtIdx, isNaN(sTxtIdx))
          if (isNaN(sTxtIdx)) {
            iCount = 0
          } else {
            iCount = parseInt(sTxtIdx) + 1
          }
        } else { // 没有TXT关联信息--直接添加即可, 索引为0
          iCount = 0
        }
        console.log(iCount)
        const aTxtCoord = oPlotData.cp[0]
        const sTxtID = 'text_' + sID + '_' + iCount // sPlotType + sPlotIDk
        this.createTxtPnt(aTxtCoord, sTxtID, sTxt)
        this.addText2xData(sID, sTxtID) // sPlotType + sPlotIDk
        // console.log(aTxtCoord, sTxtID, sTxt)
        // console.dir(this.xData)
        // 更新xData数据
        // this.updatePlot(sPlotIDk, oPlotData) -- 已经addText2xData添加了
      } else if (sAct === 'del') {
        if (oPlotData.attach) { // 有TXT关联信息
          const aTxtIDList = oPlotData.attach
          oPlotData.attach = null
          for (let i = 0; i < aTxtIDList.length; i++) {
            // 删除文字对应的军标
            this.clearPlotByGID(aTxtIDList[i])
            this.plotRecordUpdate(aTxtIDList[i], 'D') // 更新数据库-添加删除
            this.delPlotFromxDataByID(aTxtIDList[i])
            this.savePlotData2DB() // 将变更数据发到数据库
            this.sleep(500)
          }
          // 更新xData数据
          // this.updatePlot(sPlotIDk, oPlotData) -- 已经通过delPlotFromxDataByID删除了
        } // 没有气泡信息--不用处理
      } else if (sAct === 'replace') {
        // console.log('oPlotData: ', oPlotData, oPlotData.attach)
        const sTxtID = 'text_' + sID + '_0' // sPlotType + sPlotIDk
        this.clearPlotByGID(sTxtID)
        this.delPlotFromxDataByID(sTxtID)
        const aTxtCoord = oPlotData.cp[0]
        this.createTxtPnt(aTxtCoord, sTxtID, sTxt)
        // const oNewTxt = (JSON.parse(JSON.stringify(this.currPlot)))

        const plotElement = this.getPlotFromXData(sTxtID)
        plotElement.TS = new Date().getTime()
        this.plotRecordUpdate(plotElement, 'U')
        // this.plotRecordUpdate(oNewTxt, 'U') // 刷新数据库数据，第一个参数是xData的内容太
        // console.log(sID, JSON.parse(JSON.stringify(oPlotData)))
        // ------------------
        // if (oPlotData.attach) { // 有TXT信息
        //   // let aTxtIDList = oPlotData.attach
        //   // if (aTxtIDList.length > 0) {
        //   //   let oPlotTxtData = this.getPlotFromXData('text_' + sID + '_0') // sPlotType + sPlotIDk
        //   //   oPlotTxtData.style.text = sTxt
        //   // }
        //   // // 更新xData数据
        //   // this.updatePlot(sPlotIDk, oPlotData)
        //   const aTxtIDList = oPlotData.attach
        //   if (aTxtIDList.length > 0) {
        //     console.log(this.currPlot)
        //     this.plotRecordUpdate(aTxtIDList[0], 'D') // 更新数据库-添加删除
        //     this.clearPlotByGID(aTxtIDList[0])
        //     this.delPlotFromxDataByID(aTxtIDList[0])
        //     // this.savePlotData2DB() // 将变更数据发到数据库
        //     this.sleep(500)
        //   }
        //   const aTxtCoord = oPlotData.cp[0]
        //   // const sTxtID = 'text_' + sID + '_0' // sPlotType + sPlotIDk
        //   this.createTxtPnt(aTxtCoord, sTxtID, sTxt)
        //   this.addText2xData(sID, sTxtID) // 添加文字信息sPlotType + sPlotIDk
        //   this.sleep(500)
        // } else {
        //   const aTxtCoord = oPlotData.cp[0]
        //   const sTxtID = 'text_' + sID + '_0' // sPlotType + sPlotIDk
        //   this.createTxtPnt(aTxtCoord, sTxtID, sTxt)
        //   this.addText2xData(sID, sTxtID) // 添加文字信息sPlotType + sPlotIDk
        //   this.sleep(500)
        // } // ------
      }
      // 查看txt是否存在-不存在删除退出

      // 找到指定的军标，add 添加一个文字; replace;删除重新添加文字；del 删除所有数据
      // 调用文字修改方法！！！！
    },

    /**
     * @description 使用数据添加军标（需要添加指定的ID）-- 过时不再使用，可以删除
     * @param sPlotID {String}军标ID（名称）, aPnts {Array} 绘制军标所需控制点, [[经度，纬度]，[经度，纬度]...]
     *        aUnit {Array}军标尺寸（米）, sColor军标颜色(缺省为红色), cls {boolean} 是否清除原有数据，默认清空
     *        sTxt 要添加的文字，默认为空null表示不添加; oPop {Object} 军标的气泡信息，默认为空null表示不添加
     * @return 无
     */
    async data2plot_old_915 (sPlotID, aPnts, aUnit, sTxt = null, oPop = null) {
      // console.log('调用次数：', ++this.num, sPlotID)
      // await this.sleep(500)
      // console.log(sPlotID, aPnts, aUnit)
      let value = sPlotID
      if (sPlotID.length < 4) return // 长度不满足要求不做处理
      const drawType = sPlotID.substr(0, 4).toLowerCase()
      if (drawType === 'icon' || drawType === 'dire' || drawType === 'mult' || drawType === 'ddir') { // 三种vector类型处理
        value = drawType
      }
      const idStr = drawType + '_' + (new Date()).valueOf() // 创建军标唯一标识
      const sRCS = this.iMap.getView().getProjection().getCode() // 获得当前地图坐标系（this.$parent.conf.RCS）
      if (value === 'icon') { // 绘制军标
        this.$refs.pVec.clearPlotData() // 清楚原有的svg军标数据
        this.$refs.pVec.svgData = await this.$refs.pVec.getPlotDataEx(sPlotID) // 调用军标绘制所需要的SVG -- 可能需要延时处理
        // await this.sleep(500) // 等待军标数据加载完成
        let screenCoord
        if (this.sSRS !== sRCS) { // 坐标转换
          const cpx1 = olProj.transform(aPnts[0], this.sSRS, sRCS)
          screenCoord = this.iMap.getPixelFromCoordinate(cpx1)
        } else {
          // 将地理坐标转换成屏幕坐标
          screenCoord = this.iMap.getPixelFromCoordinate(aPnts[0])
        }
        // console.log(screenCoord)
        // 获得生成的军标图元{geoType：'xxx', geodata:[{},{}]}
        // this.plot_geometries = this.$refs.pVec.getFeature([screenCoord], value, this.$parent.iActType, this.iMap)
        this.plot_geometries = this.$refs.pVec.getFeature([screenCoord], value, sPlotID, this.iMap)
        // let geometryList = this.parseGeometry(newCoordinates)
        // 设置军标的线宽
        // this.setSVGStyle(this.plot_geometries, this.strokeWidth)
        this.setSVGStyle(this.plot_geometries, this.strokeWidth, this.currColor)
        // console.log(this.plot_geometries)
        this.geom2Featrue(this.plot_geometries) // 将军标绘制到标绘层（样式处理）
        this.endPlotting()
        // 将当前军标写入，军标数组！
        // this.xData.push(JSON.parse(JSON.stringify(this.currPlot)))
      } else if (value === 'dire') {
        this.$refs.pVec.clearPlotData()
        // 调用军标绘制所需要的SVG -- 可能需要延时处理
        // this.$refs.pVec.getPlotData(sPlotID)
        this.$refs.pVec.svgData = await this.$refs.pVec.getPlotDataEx(sPlotID)
        // await this.sleep(500)
        // console.log(value)
        let cp1
        let cp2
        // console.log(aPnts)
        // console.log(aPnts.length)
        // const sRCS = this.iMap.getView().getProjection().getCode() // 获得当前地图坐标系（this.$parent.conf.RCS）
        if (aPnts.length === 1) { // 如果控制点小于2需要创建第二个控制点
          // 方案的默认数据是'EPSG:4326'，要先转换成'EPSG:3857'，否则无法 与单位尺寸（米）进行计算
          const cp = olProj.transform(aPnts[0], this.sSRS, 'EPSG:3857')
          // 如果当前地图坐标不是'EPSG:3857'，要将坐标转换成地图使用坐标系统
          if (sRCS !== 'EPSG:3857') {
            cp1 = olProj.transform([cp[0] - aUnit[0], cp[1]], 'EPSG:3857', sRCS)
            cp2 = olProj.transform([cp[0] + aUnit[0], cp[1]], 'EPSG:3857', sRCS)
            cp1 = this.iMap.getPixelFromCoordinate(cp1)
            cp2 = this.iMap.getPixelFromCoordinate(cp2)
          } else {
            cp1 = this.iMap.getPixelFromCoordinate([cp[0] - aUnit[0], cp[1]])
            cp2 = this.iMap.getPixelFromCoordinate([cp[0] + aUnit[0], cp[1]])
          }
          // cp1 = this.iMap.getPixelFromCoordinate(cp1x) // 控制点1：中心点 --> 屏幕坐标
          // cp2 = this.iMap.getPixelFromCoordinate(cp2x) // 控制点2：方向点 --> 屏幕坐标
          // console.log(cp, cp1, cp2)
        } else if (aPnts.length > 1) { //  else if (aPnts.length > 2)
          // const cpx1 = olProj.transform(aPnts[0], 'EPSG:4326', 'EPSG:3857')
          // const cpx2 = olProj.transform(aPnts[1], 'EPSG:4326', 'EPSG:3857')
          // 有两个控制点，不需要进行计算获取第二空控制点，所以不用先转换成'EPSG:3857'
          if (this.sSRS !== sRCS) { // 如果数据坐标与地图坐标不相同，需要将坐标转换成地图坐标
            const cpx1 = olProj.transform(aPnts[0], this.sSRS, sRCS)
            const cpx2 = olProj.transform(aPnts[1], this.sSRS, sRCS)
            cp1 = this.iMap.getPixelFromCoordinate(cpx1) // aPnts[0]) // 控制点1：中心点
            cp2 = this.iMap.getPixelFromCoordinate(cpx2) // aPnts[1]) // 控制点2：方向点
          } else {
            cp1 = this.iMap.getPixelFromCoordinate(aPnts[0]) // aPnts[0]) // 控制点1：中心点
            cp2 = this.iMap.getPixelFromCoordinate(aPnts[1]) // aPnts[1]) // 控制点2：方向点
          }
        } else {
          return
        }
        // console.log(cp1, cp2)
        // console.log(this.currPlot)
        // 军标数据获取
        this.plot_geometries = this.$refs.pVec.getFeature([cp1, cp2], drawType, sPlotID, this.iMap)
        console.log(this.plot_geometries)
        this.setSVGStyle(this.plot_geometries, this.strokeWidth, this.currColor) // 设置军标的样式
        this.geom2Featrue()
      } else if (value === 'ddir') {
        if (aPnts.length < 2) return // 定向军标需要两个控制点（原点和方向）
        // 坐标要使用屏幕坐标
        let cp1
        let cp2
        if (this.sSRS !== sRCS) { // 如果数据坐标与地图坐标不相同，需要将坐标转换成地图坐标
          const cpx1 = olProj.transform(aPnts[0], this.sSRS, sRCS)
          const cpx2 = olProj.transform(aPnts[1], this.sSRS, sRCS)
          cp1 = this.iMap.getPixelFromCoordinate(cpx1) // aPnts[0]) // 控制点1：中心点
          cp2 = this.iMap.getPixelFromCoordinate(cpx2) // aPnts[1]) // 控制点2：方向点
        } else {
          cp1 = this.iMap.getPixelFromCoordinate(aPnts[0]) // aPnts[0]) // 控制点1：中心点
          cp2 = this.iMap.getPixelFromCoordinate(aPnts[1]) // aPnts[1]) // 控制点2：方向点
        }
        // const dx = cPnts[1][0] - cPnts[0][0] // 水平方向差值
        // const dy = cPnts[1][1] - cPnts[0][1] // 垂直方向差值
        const dy = cp2[1] - cp1[1]
        // console.log(cp2[1], '-', cp1[1], '=', dy)
        // const xTail = this.currPlot.name.substr(this.currPlot.name.length - 1, 1)
        // console.log(xTail)
        if (dy >= 0) {
          this.$refs.pVec.clearPlotData() // 清空svg军标数据
          // this.$refs.pVec.getPlotData(sPlotID + '@') // 调用军标绘制所需要的SVG -- 可能需要延时处理
          this.$refs.pVec.svgData = await this.$refs.pVec.getPlotDataEx(sPlotID + '@')
          // await this.sleep(200) // 延时处理
        } else {
          this.$refs.pVec.clearPlotData() // 清空svg军标数据
          // this.$refs.pVec.getPlotData(sPlotID) // 调用军标绘制所需要的SVG -- 可能需要延时处理
          this.$refs.pVec.svgData = await this.$refs.pVec.getPlotDataEx(sPlotID)
          // await this.sleep(200) // 延时处理
        }
        this.plot_geometries = this.$refs.pVec.getFeature([cp1, cp2], drawType, sPlotID, this.iMap)
        // console.log(this.plot_geometries)
        this.setSVGStyle(this.plot_geometries, this.strokeWidth, this.currColor) // 设置军标的样式
        this.geom2Featrue()
        // await this.sleep(1000)
      } else if (value === 'mult') {
        // 获取绘制方法名称 mult_getSimpleArrowPnts
        let funName = sPlotID.split('_')[1]
        // 获取绘制点数_名称最后一位
        const maxPnt = funName.substr(funName.length - 1, 1)
        // 最后一位为数字，需要设置绘制控制点数量，修改方法名称
        let nMaxPoints = null
        if (!isNaN(maxPnt)) { // || (isNaN(maxPnt) && isNaN(maxPnt) > 0)) {
          nMaxPoints = parseInt(maxPnt)
          funName = funName.substr(0, funName.length - 1)
        }
        if (nMaxPoints && nMaxPoints !== aPnts.length) {
          return
        }
        // console.log(funName)
        if (!funName) return
        // 查看方法是否存在，不存在退出！
        const func = plot.getFunc(funName)
        // 方法不存在退出绘制！
        if (!func) return
        // 坐标转换
        // console.log(aPnts)
        const newPnt = []
        for (let i = 0; i < aPnts.length; i++) {
          console.log(aPnts)
          let coord
          // const coord = olProj.transform(aPnts[i], 'EPSG:4326', 'EPSG:3857')
          // 如果数据坐标系不等于地图坐标系，需要转换成地图坐标系
          // console.log(this.sSRS, sRCS)
          if (this.sSRS !== sRCS) {
            coord = olProj.transform(aPnts[i], this.sSRS, sRCS)
          } else {
            coord = aPnts[i]
          }
          newPnt.push(coord)
        }
        if (newPnt.length === 2) {
          console.dir(newPnt)
          const midPnt = [(newPnt[0][0] + newPnt[1][0]) / 2, (newPnt[0][1] + newPnt[1][1]) / 2]
          newPnt.splice(1, 0, midPnt)
        }
        // console.log(newPnt)
        // 调用绘制方法，绘制箭头
        this.plot_geometries = func(newPnt)
        // console.log(this.plot_geometries)
        // 绘制完箭头后渲染
        const iStyle = {
          fill: 'none', // this.currColor,
          stroke: this.currColor,
          width: this.strokeWidth // 2
        }
        // mult类型样式补全
        for (let i = 0; i < this.plot_geometries.geoData.length; i++) {
          // let iType = this.plot_geometries.geoData[i].type
          // this.plot_geometries.geoData[i].gid = gID  // 此处应该保持统一使用idStr-方法开始出给出
          this.plot_geometries.geoData[i].gid = idStr
          // this.plot_geometries.geoData[i].style = iStyle
          this.plot_geometries.geoData[i].style = JSON.parse(JSON.stringify(iStyle))
          // console.log(iStyle)
        }

        // console.log(this.iType)
        // 实心箭头和虚线箭头样式设置（需要调整-见下面）
        if (this.iType === 'mult_getSSArrowPnts' || this.iType === 'mult_dashArrowPnts' || this.iType === 'mult_pathArrowPnts' || this.iType === 'mult_dashPathArrowPnts') {
          this.plot_geometries.geoData[0].style.fill = this.currColor
          this.plot_geometries.geoData[0].style.width = 0
        }

        // 新添加的带轮线（箭头要填充！）
        if (this.iType === 'mult_getCyyLine') {
          // 组成图形的顺序[箭头多边形，主曲线，辅助曲线，圆轮xn]
          this.plot_geometries.geoData[0].style.fill = this.currColor
          this.plot_geometries.geoData[0].style.width = 0
          this.plot_geometries.geoData[2].style.stroke = '#000000'
          this.plot_geometries.geoData[2].color = '#000000'
          // console.log(this.currPlot, this.currPlot.cp.length)
          if (this.currPlot.cp.length === 2) {
            const cp1 = this.currPlot.cp[0]
            const cp2 = this.currPlot.cp[1]
            const midPnt = [(cp1[0] + cp2[0]) / 2, (cp1[1] + cp2[1]) / 2]
            this.currPlot.cp.splice(1, 0, midPnt)
          }
        }
        // 摩托化行进
        if (this.iType === 'mult_getMotorLine') {
          // 组成图形的顺序[箭头多边形，主曲线，辅助曲线，圆轮xn]
          this.plot_geometries.geoData[0].style.fill = this.currColor
          this.plot_geometries.geoData[0].style.width = 0
          // console.log(this.currPlot, this.currPlot.cp.length)
          if (this.currPlot.cp.length === 2) {
            const cp1 = this.currPlot.cp[0]
            const cp2 = this.currPlot.cp[1]
            const midPnt = [(cp1[0] + cp2[0]) / 2, (cp1[1] + cp2[1]) / 2]
            this.currPlot.cp.splice(1, 0, midPnt)
          }
        }
        // 伴随线
        if (this.iType === 'mult_getFollowLine') {
          // 组成图形的顺序[箭头多边形，主曲线，辅助曲线，圆轮xn]
          this.plot_geometries.geoData[0].style.fill = this.currColor
          this.plot_geometries.geoData[0].style.width = 0
          this.plot_geometries.geoData[2].style.stroke = '#DEB887'
          // console.log(this.currPlot, this.currPlot.cp.length)
          if (this.currPlot.cp.length === 2) {
            const cp1 = this.currPlot.cp[0]
            const cp2 = this.currPlot.cp[1]
            const midPnt = [(cp1[0] + cp2[0]) / 2, (cp1[1] + cp2[1]) / 2]
            this.currPlot.cp.splice(1, 0, midPnt)
          }
        }

        // 虚线的处理
        if (this.iType === 'mult_dashArrowPnts' || this.iType === 'mult_dashPathArrowPnts') {
          this.plot_geometries.geoData[1].style.lineDash = [20, 10]
        }
        // 将标绘图形加入标绘层
        this.geom2Featrue()
        // 当前会信息补全
        this.currPlot.id = idStr
        this.currPlot.name = sPlotID // 类型为多边形 还是iType？
        this.currPlot.cp = newPnt // ctrlpoint控制点，包含中心点 已经在绘制时更新
        this.currPlot.scale = 1
        this.currPlot.rotate = 0
        this.currPlot.color = this.currColor // 颜色（样式需要更详细些，可能还会有虚线！）
        this.currPlot.unit = null // 基础多边形不需要次属性
        this.currPlot.attach = null // 关联文字数组！
        this.currPlot.boxWH = null // mult不需要此数据
      } // else if (value === 'text')
      const dCache = JSON.parse(JSON.stringify(this.currPlot))
      this.xData.push(dCache)

      let aTxtCoord
      if (sTxt) {
        // console.log('需要添加文本内容' + sTxt)
        if (sPlotID === 'mult_getSimpleArrowEW') { // || sPlotID === 'mult_pathArrowPnts'
          aTxtCoord = this.currPlot.cp[1]
        } else {
          aTxtCoord = this.getPlotCenter(this.currPlot)// 获得军标的中心位置
        }
        // console.log(aTxtCoord, idStr)
        const sTxtID = 'text_' + idStr + '_0' // _0 关联文字数量txtNum
        // 创建文字currPlot信息，然后调用方法;basePnt, txtID, txt = '请添加文字', fontStyle = 'normal 12px 微软雅黑'
        this.createTxtPnt(aTxtCoord, sTxtID, sTxt) // 文字去掉了白边
        this.currPlotAddUserTime() // 添加用户和时间戳(从createTxtPnt中移到此)
        // this.createTxtPlot(currPlot)
        this.addText2xData(idStr, sTxtID)
      }
      // 新添加的弹出气泡信息
      if (oPop) {
        // 调用plotPanel中的addPlotPop(sPlotID, oPopInfos) 参数：军标的ID,军标提示气泡信息
        // console.log(sPlotID, this.currPlot.id)
        this.addPlotPop(this.currPlot.id, oPop) // 最终会在xData中找到对应的军标并添加pop气泡信息
      }
      // console.log(this.xData)
    },
    // 添加了指定ID
    async data2plot (sPlotID, sPlotType, aPnts, aUnit, sTxt = null, oPop = null, sColor = null) {
      // sPlotID = sPlotID || (new Date()).valueOf() // 创建军标唯一标识
      if (!sPlotID) {
        sPlotID = (new Date()).valueOf()
      }
      console.log('调用次数：', ++this.num, sPlotID)
      // await this.sleep(500)
      // console.log(sPlotID, sPlotType, aPnts, aUnit)
      let value = sPlotType
      if (sPlotType.length < 4) return // 长度不满足要求不做处理
      // const drawType = sPlotID.substr(0, 4).toLowerCase()
      const drawType = sPlotType.substr(0, 4).toLowerCase()
      if (drawType === 'icon' || drawType === 'dire' || drawType === 'mult' || drawType === 'ddir' || drawType === 'route') { // 三种vector类型处理
        value = drawType
      }
      // const idStr = drawType + '_' + (new Date()).valueOf() // 创建军标唯一标识
      // const idStr = drawType + '_' + sPlotID // 创建军标唯一标识
      const idStr = value + '_' + sPlotID // 创建军标唯一标识
      // const sRCS = this.iMap.getView().getProjection().getCode() // 获得当前地图坐标系（this.$parent.conf.RCS）
      const sRCS = this.$parent.conf.RCS
      if (value === 'icon') { // 绘制军标
        this.$refs.pVec.clearPlotData() // 清除原有的svg军标数据
        this.$refs.pVec.svgData = await this.$refs.pVec.getPlotDataEx(sPlotType) // 调用军标绘制所需要的SVG -- 可能需要延时处理
        // await this.sleep(500) // 等待军标数据加载完成
        let screenCoord
        if (this.sSRS !== sRCS) { // 坐标转换
          const cpx1 = olProj.transform(aPnts[0], this.sSRS, sRCS)
          screenCoord = this.iMap.getPixelFromCoordinate(cpx1)
        } else {
          // 将地理坐标转换成屏幕坐标
          screenCoord = this.iMap.getPixelFromCoordinate(aPnts[0])
        }
        // console.log(screenCoord)
        // 获得生成的军标图元{geoType：'xxx', geodata:[{},{}]}
        // this.plot_geometries = this.$refs.pVec.getFeature([screenCoord], value, this.$parent.iActType, this.iMap)
        // this.plot_geometries = this.$refs.pVec.getFeature([screenCoord], value, sPlotType, this.iMap) // 添加id
        this.plot_geometries = this.$refs.pVec.getFeature4Sol(idStr, [screenCoord], value, sPlotType, this.iMap)
        // let geometryList = this.parseGeometry(newCoordinates)
        // 设置军标的线宽
        // this.setSVGStyle(this.plot_geometries, this.strokeWidth)
        this.setSVGStyle(this.plot_geometries, this.strokeWidth, this.currColor)
        // console.log(this.plot_geometries)
        this.geom2Featrue(this.plot_geometries) // 将军标绘制到标绘层（样式处理）
        this.currPlotAddUserTime() // 添加用户和时间戳
        this.endPlotting()
        // 将当前军标写入，军标数组！
        // this.xData.push(JSON.parse(JSON.stringify(this.currPlot)))
      } else if (value === 'dire') {
        this.$refs.pVec.clearPlotData()
        // 调用军标绘制所需要的SVG -- 可能需要延时处理
        // this.$refs.pVec.getPlotData(sPlotID)
        this.$refs.pVec.svgData = await this.$refs.pVec.getPlotDataEx(sPlotType)
        // await this.sleep(500)
        // console.log(value)
        let cp1
        let cp2
        // console.log(aPnts)
        // console.log(aPnts.length)
        // const sRCS = this.iMap.getView().getProjection().getCode() // 获得当前地图坐标系（this.$parent.conf.RCS）
        if (aPnts.length === 1) { // 如果控制点小于2需要创建第二个控制点
          // 方案的默认数据是'EPSG:4326'，要先转换成'EPSG:3857'，否则无法 与单位尺寸（米）进行计算
          const cp = olProj.transform(aPnts[0], this.sSRS, 'EPSG:3857')
          // 如果当前地图坐标不是'EPSG:3857'，要将坐标转换成地图使用坐标系统
          if (sRCS !== 'EPSG:3857') {
            cp1 = olProj.transform([cp[0] - aUnit[0], cp[1]], 'EPSG:3857', sRCS)
            cp2 = olProj.transform([cp[0] + aUnit[0], cp[1]], 'EPSG:3857', sRCS)
            cp1 = this.iMap.getPixelFromCoordinate(cp1)
            cp2 = this.iMap.getPixelFromCoordinate(cp2)
          } else {
            cp1 = this.iMap.getPixelFromCoordinate([cp[0] - aUnit[0], cp[1]])
            cp2 = this.iMap.getPixelFromCoordinate([cp[0] + aUnit[0], cp[1]])
          }
          // cp1 = this.iMap.getPixelFromCoordinate(cp1x) // 控制点1：中心点 --> 屏幕坐标
          // cp2 = this.iMap.getPixelFromCoordinate(cp2x) // 控制点2：方向点 --> 屏幕坐标
          // console.log(cp, cp1, cp2)
        } else if (aPnts.length > 1) { //  else if (aPnts.length > 2)
          // const cpx1 = olProj.transform(aPnts[0], 'EPSG:4326', 'EPSG:3857')
          // const cpx2 = olProj.transform(aPnts[1], 'EPSG:4326', 'EPSG:3857')
          // 有两个控制点，不需要进行计算获取第二空控制点，所以不用先转换成'EPSG:3857'
          if (this.sSRS !== sRCS) { // 如果数据坐标与地图坐标不相同，需要将坐标转换成地图坐标
            const cpx1 = olProj.transform(aPnts[0], this.sSRS, sRCS)
            const cpx2 = olProj.transform(aPnts[1], this.sSRS, sRCS)
            cp1 = this.iMap.getPixelFromCoordinate(cpx1) // aPnts[0]) // 控制点1：中心点
            cp2 = this.iMap.getPixelFromCoordinate(cpx2) // aPnts[1]) // 控制点2：方向点
          } else {
            cp1 = this.iMap.getPixelFromCoordinate(aPnts[0]) // aPnts[0]) // 控制点1：中心点
            cp2 = this.iMap.getPixelFromCoordinate(aPnts[1]) // aPnts[1]) // 控制点2：方向点
          }
        } else {
          return
        }
        // console.log(cp1, cp2)
        // console.log(this.currPlot)
        // 军标数据获取
        // this.plot_geometries = this.$refs.pVec.getFeature([cp1, cp2], drawType, sPlotType, this.iMap)
        this.plot_geometries = this.$refs.pVec.getFeature4Sol(idStr, [cp1, cp2], drawType, sPlotType, this.iMap)
        console.log(this.plot_geometries)
        this.setSVGStyle(this.plot_geometries, this.strokeWidth, this.currColor) // 设置军标的样式
        this.geom2Featrue()
        this.currPlotAddUserTime() // 添加用户和时间戳
      } else if (value === 'ddir') {
        if (aPnts.length < 2) return // 定向军标需要两个控制点（原点和方向）
        // 坐标要使用屏幕坐标
        let cp1
        let cp2
        if (this.sSRS !== sRCS) { // 如果数据坐标与地图坐标不相同，需要将坐标转换成地图坐标
          const cpx1 = olProj.transform(aPnts[0], this.sSRS, sRCS)
          const cpx2 = olProj.transform(aPnts[1], this.sSRS, sRCS)
          cp1 = this.iMap.getPixelFromCoordinate(cpx1) // aPnts[0]) // 控制点1：中心点
          cp2 = this.iMap.getPixelFromCoordinate(cpx2) // aPnts[1]) // 控制点2：方向点
        } else {
          cp1 = this.iMap.getPixelFromCoordinate(aPnts[0]) // aPnts[0]) // 控制点1：中心点
          cp2 = this.iMap.getPixelFromCoordinate(aPnts[1]) // aPnts[1]) // 控制点2：方向点
        }
        // const dx = cPnts[1][0] - cPnts[0][0] // 水平方向差值
        // const dy = cPnts[1][1] - cPnts[0][1] // 垂直方向差值
        const dy = cp2[1] - cp1[1]
        // console.log(cp2[1], '-', cp1[1], '=', dy)
        // const xTail = this.currPlot.name.substr(this.currPlot.name.length - 1, 1)
        // console.log(xTail)
        if (dy >= 0) {
          this.$refs.pVec.clearPlotData() // 清空svg军标数据
          // this.$refs.pVec.getPlotData(sPlotType + '@') // 调用军标绘制所需要的SVG -- 可能需要延时处理
          this.$refs.pVec.svgData = await this.$refs.pVec.getPlotDataEx(sPlotType + '@')
          // await this.sleep(200) // 延时处理
        } else {
          this.$refs.pVec.clearPlotData() // 清空svg军标数据
          // this.$refs.pVec.getPlotData(sPlotType) // 调用军标绘制所需要的SVG -- 可能需要延时处理
          this.$refs.pVec.svgData = await this.$refs.pVec.getPlotDataEx(sPlotType)
          // await this.sleep(200) // 延时处理
        }
        // this.plot_geometries = this.$refs.pVec.getFeature([cp1, cp2], drawType, sPlotType, this.iMap)
        this.plot_geometries = this.$refs.pVec.getFeature4Sol(idStr, [cp1, cp2], drawType, sPlotType, this.iMap)
        // console.log(this.plot_geometries)
        this.setSVGStyle(this.plot_geometries, this.strokeWidth, this.currColor) // 设置军标的样式
        this.geom2Featrue()
        this.currPlotAddUserTime() // 添加用户和时间戳
        // await this.sleep(1000)
      } else if (value === 'mult') {
        // 获取绘制方法名称 mult_getSimpleArrowPnts
        let funName = sPlotType.split('_')[1]
        // 获取绘制点数_名称最后一位
        const maxPnt = funName.substr(funName.length - 1, 1)
        // 最后一位为数字，需要设置绘制控制点数量，修改方法名称
        let nMaxPoints = null
        if (!isNaN(maxPnt)) { // || (isNaN(maxPnt) && isNaN(maxPnt) > 0)) {
          nMaxPoints = parseInt(maxPnt)
          funName = funName.substr(0, funName.length - 1)
        }
        if (nMaxPoints && nMaxPoints !== aPnts.length) {
          return
        }
        // console.log(funName)
        if (!funName) return
        // 查看方法是否存在，不存在退出！
        const func = plot.getFunc(funName)
        // 方法不存在退出绘制！
        if (!func) return
        // 坐标转换
        // console.log(aPnts)
        const newPnt = []
        for (let i = 0; i < aPnts.length; i++) {
          console.log(aPnts)
          let coord
          // const coord = olProj.transform(aPnts[i], 'EPSG:4326', 'EPSG:3857')
          // 如果数据坐标系不等于地图坐标系，需要转换成地图坐标系
          // console.log(this.sSRS, sRCS)
          if (this.sSRS !== sRCS) {
            coord = olProj.transform(aPnts[i], this.sSRS, sRCS)
          } else {
            coord = aPnts[i]
          }
          newPnt.push(coord)
        }
        if (newPnt.length === 2) {
          console.dir(newPnt)
          const midPnt = [(newPnt[0][0] + newPnt[1][0]) / 2, (newPnt[0][1] + newPnt[1][1]) / 2]
          newPnt.splice(1, 0, midPnt)
        }
        // console.log(newPnt)
        // 调用绘制方法，绘制箭头
        this.plot_geometries = func(newPnt)
        // console.log(this.plot_geometries)
        // 绘制完箭头后渲染
        const iStyle = {
          fill: 'none', // this.currColor,
          stroke: this.currColor,
          width: this.strokeWidth // 2
        }
        // mult类型样式补全
        for (let i = 0; i < this.plot_geometries.geoData.length; i++) {
          // let iType = this.plot_geometries.geoData[i].type
          // this.plot_geometries.geoData[i].gid = gID  // 此处应该保持统一使用idStr-方法开始出给出
          this.plot_geometries.geoData[i].gid = idStr
          // this.plot_geometries.geoData[i].style = iStyle
          this.plot_geometries.geoData[i].style = JSON.parse(JSON.stringify(iStyle))
          // console.log(iStyle)
        }

        // console.log(this.iType)
        // 实心箭头和虚线箭头样式设置（需要调整-见下面）
        if (this.iType === 'mult_getSSArrowPnts' || this.iType === 'mult_dashArrowPnts' || this.iType === 'mult_pathArrowPnts' || this.iType === 'mult_dashPathArrowPnts') {
          this.plot_geometries.geoData[0].style.fill = this.currColor
          this.plot_geometries.geoData[0].style.width = 0
        }

        // 新添加的带轮线（箭头要填充！）
        if (this.iType === 'mult_getCyyLine') {
          // 组成图形的顺序[箭头多边形，主曲线，辅助曲线，圆轮xn]
          this.plot_geometries.geoData[0].style.fill = this.currColor
          this.plot_geometries.geoData[0].style.width = 0
          this.plot_geometries.geoData[2].style.stroke = '#000000'
          this.plot_geometries.geoData[2].color = '#000000'
          // console.log(this.currPlot, this.currPlot.cp.length)
          if (this.currPlot.cp.length === 2) {
            const cp1 = this.currPlot.cp[0]
            const cp2 = this.currPlot.cp[1]
            const midPnt = [(cp1[0] + cp2[0]) / 2, (cp1[1] + cp2[1]) / 2]
            this.currPlot.cp.splice(1, 0, midPnt)
          }
        }
        // 摩托化行进
        if (this.iType === 'mult_getMotorLine') {
          // 组成图形的顺序[箭头多边形，主曲线，辅助曲线，圆轮xn]
          this.plot_geometries.geoData[0].style.fill = this.currColor
          this.plot_geometries.geoData[0].style.width = 0
          // console.log(this.currPlot, this.currPlot.cp.length)
          if (this.currPlot.cp.length === 2) {
            const cp1 = this.currPlot.cp[0]
            const cp2 = this.currPlot.cp[1]
            const midPnt = [(cp1[0] + cp2[0]) / 2, (cp1[1] + cp2[1]) / 2]
            this.currPlot.cp.splice(1, 0, midPnt)
          }
        }
        // 伴随线
        if (this.iType === 'mult_getFollowLine') {
          // 组成图形的顺序[箭头多边形，主曲线，辅助曲线，圆轮xn]
          this.plot_geometries.geoData[0].style.fill = this.currColor
          this.plot_geometries.geoData[0].style.width = 0
          this.plot_geometries.geoData[2].style.stroke = '#DEB887'
          // console.log(this.currPlot, this.currPlot.cp.length)
          if (this.currPlot.cp.length === 2) {
            const cp1 = this.currPlot.cp[0]
            const cp2 = this.currPlot.cp[1]
            const midPnt = [(cp1[0] + cp2[0]) / 2, (cp1[1] + cp2[1]) / 2]
            this.currPlot.cp.splice(1, 0, midPnt)
          }
        }

        // 虚线的处理
        if (this.iType === 'mult_dashArrowPnts' || this.iType === 'mult_dashPathArrowPnts') {
          this.plot_geometries.geoData[1].style.lineDash = [20, 10]
        }
        // 将标绘图形加入标绘层
        this.geom2Featrue()
        // 当前会信息补全
        this.currPlot.id = idStr
        this.currPlot.name = sPlotType // 类型为多边形 还是iType？
        this.currPlot.cp = newPnt // ctrlpoint控制点，包含中心点 已经在绘制时更新
        this.currPlot.scale = 1
        this.currPlot.rotate = 0
        this.currPlot.color = this.currColor // 颜色（样式需要更详细些，可能还会有虚线！）
        this.currPlot.unit = null // 基础多边形不需要次属性
        this.currPlot.attach = null // 关联文字数组！
        this.currPlot.boxWH = null // mult不需要此数据
        // -- 添加更新
        this.currPlotAddUserTime() // 添加用户和时间戳
      } else if (value === 'route') { // 可以改成路径规划LineString -->route
        if (aPnts.length > 1) {
          console.log(sRCS)
          let aCtrlPoints = []
          if (sRCS !== 'EPSG:4326') { // -- 路径规划使用4326
            // 将坐标转换成当前地图坐标
            console.log('坐标转换')
            for (let i = 0; i < aPnts.length; i++) {
              const aTmpCoord = olProj.transform(aPnts[i], 'EPSG:4326', sRCS) // aPnts[i], this.sSRS, 'EPSG:3857'
              aCtrlPoints.push(aTmpCoord)
            }
          } else {
            aCtrlPoints = aPnts
          }
          // 调用方法生成折线 sPlotID, sPlotType, aPnts, aUnit, sTxt = null, oPop = null
          // this.createBasePlot (sPlotID, sPlotType, aPnts, aUnit) //, sColor)
          console.log(idStr)
          this.currPlot.id = idStr // 'route_' + sPlotID// sPlotID
          this.currPlot.name = 'LineString' // sPlotType // 类型为多边形 还是iType？
          this.currPlot.cp = aCtrlPoints // ctrlpoint控制点，包含中心点
          this.currPlot.scale = 1
          this.currPlot.rotate = 0
          this.currPlot.unit = null // 基础多边形不需要次属性
          this.currPlot.attach = null // 关联文字数组！
          this.currPlot.boxWH = null // LineStrion不需要此数据
          // alert(sColor)
          if (sColor) {
            const sOldColor = this.currColor
            this.currColor = sColor // 修改当前绘制颜色
            this.currPlot.color = sColor // 需要设置备选路径颜色
            this.setCurrPlotStyle('rgba(0,0,0,0)', sColor, this.strokeWidth)
            this.createBasePlot(this.currPlot) // , 'EPSG:4326' 根据设置颜色绘制
            this.currColor = sOldColor // '#ff0000'
          } else {
            this.currPlot.color = this.currColor // 颜色（样式需要更详细些，可能还会有虚线！）
            this.setCurrPlotStyle('rgba(0,0,0,0)', this.currColor, this.strokeWidth)
            console.log(this.currPlot)
            this.createBasePlot(this.currPlot) // , 'EPSG:4326'
          }
          this.currPlotAddUserTime() // 添加用户和时间戳
        }
      } // else if (value === 'text')
      // this.currPlotAddUserTime() // 添加用户和时间戳
      const dCache = JSON.parse(JSON.stringify(this.currPlot))
      this.xData.push(dCache)

      let aTxtCoord
      if (sTxt) {
        // console.log('需要添加文本内容' + sTxt)
        if (sPlotType === 'mult_getSimpleArrowEW') { // || sPlotID === 'mult_pathArrowPnts'
          aTxtCoord = this.currPlot.cp[1]
        } else {
          aTxtCoord = this.getPlotCenter(this.currPlot)// 获得军标的中心位置
        }
        // console.log(aTxtCoord, idStr)
        const sTxtID = 'text_' + idStr + '_0' // _0 关联文字数量txtNum
        // 创建文字currPlot信息，然后调用方法;basePnt, txtID, txt = '请添加文字', fontStyle = 'normal 12px 微软雅黑'
        this.createTxtPnt(aTxtCoord, sTxtID, sTxt) // 文字去掉了白边
        this.currPlotAddUserTime() // 添加用户和时间戳(从createTxtPnt中移到此)
        // this.createTxtPlot(currPlot)
        this.addText2xData(idStr, sTxtID)
      }
      // 新添加的弹出气泡信息
      if (oPop) {
        // 调用plotPanel中的addPlotPop(sPlotType, oPopInfos) 参数：军标的ID,军标提示气泡信息
        // console.log(sPlotType, this.currPlot.id)
        this.addPlotPop(this.currPlot.id, oPop) // 最终会在xData中找到对应的军标并添加pop气泡信息
      }
      // console.log(this.xData)
    }
    // 当前方法
  }
}
